पाइथन FastAPI एरर हैंडलिंग: मजबूत कस्टम एक्सेप्शन हैंडलर बनाना

मजबूत और विश्वसनीय API बनाने में एरर हैंडलिंग एक महत्वपूर्ण पहलू है। पाइथन के FastAPI में, आप त्रुटियों को शालीनता से प्रबंधित करने और क्लाइंट को सूचनात्मक प्रतिक्रियाएँ प्रदान करने के लिए कस्टम एक्सेप्शन हैंडलर का लाभ उठा सकते हैं। यह ब्लॉग पोस्ट आपको FastAPI में कस्टम एक्सेप्शन हैंडलर बनाने की प्रक्रिया के बारे में मार्गदर्शन करेगा, जिससे आप अधिक लचीले और उपयोगकर्ता-अनुकूल एप्लिकेशन बना सकेंगे।

कस्टम एक्सेप्शन हैंडलर क्यों?

FastAPI एक्सेप्शन को संभालने के लिए अंतर्निहित समर्थन प्रदान करता है। हालाँकि, केवल डिफ़ॉल्ट त्रुटि प्रतिक्रियाओं पर निर्भर रहने से क्लाइंट को अस्पष्ट या अनुपयोगी जानकारी मिल सकती है। कस्टम एक्सेप्शन हैंडलर कई फायदे प्रदान करते हैं:

• बेहतर उपयोगकर्ता अनुभव: विशिष्ट त्रुटि परिदृश्यों के अनुरूप स्पष्ट और सूचनात्मक त्रुटि संदेश प्रदान करें।
• केंद्रीकृत त्रुटि प्रबंधन: त्रुटि प्रबंधन लॉजिक को एक ही स्थान पर समेकित करें, जिससे आपका कोड अधिक रखरखाव योग्य हो जाता है।
• संगत त्रुटि प्रतिक्रियाएँ: सुनिश्चित करें कि त्रुटि प्रतिक्रियाएँ एक सुसंगत प्रारूप का पालन करती हैं, जिससे API उपयोगिता में सुधार होता है।
• बढ़ी हुई सुरक्षा: संवेदनशील जानकारी को त्रुटि संदेशों में उजागर होने से रोकें।
• कस्टम लॉगिंग: डिबगिंग और निगरानी उद्देश्यों के लिए विस्तृत त्रुटि जानकारी लॉग करें।

FastAPI के एक्सेप्शन हैंडलिंग को समझना

FastAPI त्रुटियों को प्रबंधित करने के लिए पाइथन के अंतर्निहित एक्सेप्शन हैंडलिंग तंत्र और अपने स्वयं के डिपेंडेंसी इंजेक्शन सिस्टम के संयोजन का उपयोग करता है। जब किसी रूट या डिपेंडेंसी के भीतर कोई एक्सेप्शन उठाया जाता है, तो FastAPI इसे संसाधित करने के लिए एक उपयुक्त एक्सेप्शन हैंडलर की खोज करता है।

एक्सेप्शन हैंडलर @app.exception_handler() से सजाए गए फ़ंक्शन होते हैं जो दो तर्क लेते हैं: एक्सेप्शन का प्रकार और रिक्वेस्ट ऑब्जेक्ट। हैंडलर एक उपयुक्त HTTP प्रतिक्रिया लौटाने के लिए जिम्मेदार होता है।

कस्टम एक्सेप्शन बनाना

कस्टम एक्सेप्शन हैंडलर को परिभाषित करने से पहले, कस्टम एक्सेप्शन क्लास बनाना अक्सर फायदेमंद होता है जो आपके एप्लिकेशन में विशिष्ट त्रुटि स्थितियों का प्रतिनिधित्व करते हैं। यह कोड पठनीयता में सुधार करता है और विभिन्न प्रकार की त्रुटियों को संभालना आसान बनाता है।

उदाहरण के लिए, मान लें कि आप एक ई-कॉमर्स API बना रहे हैं और उन मामलों को संभालने की आवश्यकता है जहां कोई उत्पाद स्टॉक में नहीं है। आप OutOfStockError नामक एक कस्टम एक्सेप्शन क्लास परिभाषित कर सकते हैं:

            
class OutOfStockError(Exception):
    def __init__(self, product_id: int):
        self.product_id = product_id
        self.message = f"Product with ID {product_id} is out of stock."

            

              
                Copy
              
            
          

यह कस्टम एक्सेप्शन क्लास बेस Exception क्लास से विरासत में मिला है और इसमें एक product_id एट्रिब्यूट और एक कस्टम त्रुटि संदेश शामिल है।

कस्टम एक्सेप्शन हैंडलर्स को लागू करना

अब, आइए OutOfStockError के लिए एक कस्टम एक्सेप्शन हैंडलर बनाएँ। यह हैंडलर एक्सेप्शन को पकड़ेगा और एक HTTP 400 (Bad Request) प्रतिक्रिया लौटाएगा जिसमें त्रुटि संदेश युक्त एक JSON बॉडी होगी।

            
from fastapi import FastAPI, Request, HTTPException
from fastapi.responses import JSONResponse

app = FastAPI()

class OutOfStockError(Exception):
    def __init__(self, product_id: int):
        self.product_id = product_id
        self.message = f"Product with ID {product_id} is out of stock."

@app.exception_handler(OutOfStockError)
async def out_of_stock_exception_handler(request: Request, exc: OutOfStockError):
    return JSONResponse(
        status_code=400,
        content={"message": exc.message},
    )

@app.get("/products/{product_id}")
async def get_product(product_id: int):
    # Simulate checking product stock
    if product_id == 123:
        raise OutOfStockError(product_id=product_id)
    return {"product_id": product_id, "name": "Example Product", "price": 29.99}

            

              
                Copy
              
            
          

इस उदाहरण में, @app.exception_handler(OutOfStockError) डेकोरेटर out_of_stock_exception_handler फ़ंक्शन को OutOfStockError एक्सेप्शन को संभालने के लिए पंजीकृत करता है। जब get_product रूट में OutOfStockError उठाया जाता है, तो एक्सेप्शन हैंडलर को लागू किया जाता है। फिर हैंडलर 400 की स्थिति कोड और त्रुटि संदेश युक्त JSON बॉडी के साथ एक JSONResponse लौटाता है।

कई एक्सेप्शन प्रकारों को संभालना

आप विभिन्न प्रकार के एक्सेप्शन को संभालने के लिए कई एक्सेप्शन हैंडलर परिभाषित कर सकते हैं। उदाहरण के लिए, आप उपयोगकर्ता इनपुट को पार्स करते समय होने वाले ValueError एक्सेप्शन को संभालना चाह सकते हैं।

            
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse

app = FastAPI()

@app.exception_handler(ValueError)
async def value_error_exception_handler(request: Request, exc: ValueError):
    return JSONResponse(
        status_code=400,
        content={"message": str(exc)},
    )

@app.get("/items/{item_id}")
async def get_item(item_id: int):
    # Simulate invalid item_id
    if item_id < 0:
        raise ValueError("Item ID must be a positive integer.")
    return {"item_id": item_id, "name": "Example Item"}

            

              
                Copy
              
            
          

इस उदाहरण में, value_error_exception_handler फ़ंक्शन ValueError एक्सेप्शन को संभालता है। यह एक्सेप्शन ऑब्जेक्ट से त्रुटि संदेश निकालता है और इसे JSON प्रतिक्रिया में लौटाता है।

HTTPException का उपयोग करना

FastAPI एक अंतर्निहित एक्सेप्शन क्लास प्रदान करता है जिसे HTTPException कहा जाता है जिसका उपयोग HTTP-विशिष्ट त्रुटियों को उठाने के लिए किया जा सकता है। यह सामान्य त्रुटि परिदृश्यों जैसे अनधिकृत पहुंच या संसाधन नहीं मिलने को संभालने के लिए उपयोगी हो सकता है।

            
from fastapi import FastAPI, HTTPException

app = FastAPI()

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    # Simulate user not found
    if user_id == 999:
        raise HTTPException(status_code=404, detail="User not found")
    return {"user_id": user_id, "name": "Example User"}

            

              
                Copy
              
            
          

इस उदाहरण में, HTTPException को 404 (Not Found) के स्टेटस कोड और एक विवरण संदेश के साथ उठाया गया है। FastAPI स्वचालित रूप से HTTPException एक्सेप्शन को संभालता है और निर्दिष्ट स्टेटस कोड और विवरण संदेश के साथ एक JSON प्रतिक्रिया लौटाता है।

ग्लोबल एक्सेप्शन हैंडलर्स

आप ग्लोबल एक्सेप्शन हैंडलर भी परिभाषित कर सकते हैं जो सभी अनहैंडल्ड एक्सेप्शन को पकड़ते हैं। यह त्रुटियों को लॉग करने या क्लाइंट को एक सामान्य त्रुटि संदेश लौटाने के लिए उपयोगी हो सकता है।

            
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
import logging

app = FastAPI()

logger = logging.getLogger(__name__)

@app.exception_handler(Exception)
async def global_exception_handler(request: Request, exc: Exception):
    logger.exception(f"Unhandled exception: {exc}")
    return JSONResponse(
        status_code=500,
        content={"message": "Internal server error"},
    )

@app.get("/error")
async def trigger_error():
    raise ValueError("This is a test error.")

            

              
                Copy
              
            
          

इस उदाहरण में, global_exception_handler फ़ंक्शन उन सभी एक्सेप्शन को संभालता है जो अन्य एक्सेप्शन हैंडलर्स द्वारा नहीं संभाले जाते हैं। यह त्रुटि को लॉग करता है और एक सामान्य त्रुटि संदेश के साथ 500 (Internal Server Error) प्रतिक्रिया लौटाता है।

एक्सेप्शन हैंडलिंग के लिए मिडलवेयर का उपयोग करना

एक्सेप्शन हैंडलिंग का एक और तरीका मिडलवेयर का उपयोग करना है। मिडलवेयर फ़ंक्शन प्रत्येक अनुरोध से पहले और बाद में निष्पादित होते हैं, जिससे आप उच्च स्तर पर एक्सेप्शन को रोक सकते हैं और संभाल सकते हैं। यह अनुरोधों और प्रतिक्रियाओं को लॉग करने, या कस्टम प्रमाणीकरण या प्राधिकरण लॉजिक को लागू करने जैसे कार्यों के लिए उपयोगी हो सकता है।

            
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
import logging

app = FastAPI()

logger = logging.getLogger(__name__)

@app.middleware("http")
async def exception_middleware(request: Request, call_next):
    try:
        response = await call_next(request)
    except Exception as exc:
        logger.exception(f"Unhandled exception: {exc}")
        return JSONResponse(
            status_code=500,
            content={"message": "Internal server error"},
        )
    return response

@app.get("/error")
async def trigger_error():
    raise ValueError("This is a test error.")

            

              
                Copy
              
            
          

इस उदाहरण में, exception_middleware फ़ंक्शन अनुरोध प्रसंस्करण लॉजिक को try...except ब्लॉक में लपेटता है। यदि अनुरोध प्रसंस्करण के दौरान कोई एक्सेप्शन उठाया जाता है, तो मिडलवेयर त्रुटि को लॉग करता है और 500 (Internal Server Error) प्रतिक्रिया लौटाता है।

उदाहरण: अंतर्राष्ट्रीयकरण (i18n) और त्रुटि संदेश

वैश्विक दर्शकों के लिए API बनाते समय, अपने त्रुटि संदेशों का अंतर्राष्ट्रीयकरण करने पर विचार करें। इसमें उपयोगकर्ता के लोकेल के आधार पर विभिन्न भाषाओं में त्रुटि संदेश प्रदान करना शामिल है। जबकि पूर्ण i18n को लागू करना इस लेख के दायरे से बाहर है, यहाँ अवधारणा को प्रदर्शित करने वाला एक सरलीकृत उदाहरण है:

            
from fastapi import FastAPI, Request, HTTPException
from fastapi.responses import JSONResponse
from typing import Dict

app = FastAPI()

# Mock translation dictionary (replace with a real i18n library)
translations: Dict[str, Dict[str, str]] = {
    "en": {
        "product_not_found": "Product with ID {product_id} not found.",
        "invalid_input": "Invalid input: {error_message}",
    },
    "fr": {
        "product_not_found": "Produit avec l'ID {product_id} introuvable.",
        "invalid_input": "Entrée invalide : {error_message}",
    },
    "es": {
        "product_not_found": "Producto con ID {product_id} no encontrado.",
        "invalid_input": "Entrada inválida: {error_message}",
    },
    "de": {
        "product_not_found": "Produkt mit ID {product_id} nicht gefunden.",
        "invalid_input": "Ungültige Eingabe: {error_message}",
    }
}

def get_translation(locale: str, key: str, **kwargs) -> str:
    """Retrieves a translation for a given locale and key.
    If the locale or key is not found, returns a default message.
    """
    if locale in translations and key in translations[locale]:
        return translations[locale][key].format(**kwargs)
    return f"Translation missing for key '{key}' in locale '{locale}'."

@app.get("/products/{product_id}")
async def get_product(request: Request, product_id: int, locale: str = "en"):
    # Simulate product lookup
    if product_id > 100:
        message = get_translation(locale, "product_not_found", product_id=product_id)
        raise HTTPException(status_code=404, detail=message)

    if product_id < 0:
         message = get_translation(locale, "invalid_input", error_message="Product ID must be positive")
         raise HTTPException(status_code=400, detail=message)

    return {"product_id": product_id, "name": "Example Product"}

            

              
                Copy
              
            
          

i18n उदाहरण के लिए मुख्य सुधार:

• लोकेल पैरामीटर: रूट अब एक locale क्वेरी पैरामीटर स्वीकार करता है, जिससे क्लाइंट अपनी पसंदीदा भाषा निर्दिष्ट कर सकते हैं (डिफ़ॉल्ट रूप से "en" अंग्रेजी के लिए)।
• अनुवाद शब्दकोश: एक translations शब्दकोश (मॉक) विभिन्न लोकेल (इस मामले में अंग्रेजी, फ्रेंच, स्पेनिश, जर्मन) के लिए त्रुटि संदेश संग्रहीत करता है। एक वास्तविक एप्लिकेशन में, आप एक समर्पित i18n लाइब्रेरी का उपयोग करेंगे।
• get_translation फ़ंक्शन: यह सहायक फ़ंक्शन locale और key के आधार पर उपयुक्त अनुवाद प्राप्त करता है। यह गतिशील मान (जैसे product_id) डालने के लिए स्ट्रिंग स्वरूपण का भी समर्थन करता है।
• गतिशील त्रुटि संदेश: HTTPException अब एक detail संदेश के साथ उठाया जाता है जो get_translation फ़ंक्शन का उपयोग करके गतिशील रूप से उत्पन्न होता है।

जब कोई क्लाइंट /products/101?locale=fr का अनुरोध करता है, तो उसे फ्रेंच में एक त्रुटि संदेश प्राप्त होगा (यदि अनुवाद उपलब्ध है)। जब /products/-1?locale=es का अनुरोध किया जाता है, तो उन्हें स्पेनिश में ऋणात्मक आईडी के बारे में एक त्रुटि संदेश मिलेगा (यदि उपलब्ध हो)। जब /products/200?locale=xx (बिना अनुवाद वाला लोकेल) का अनुरोध किया जाता है, तो उन्हें `Translation missing` संदेश मिलेगा।

एरर हैंडलिंग के लिए सर्वोत्तम प्रथाएँ

FastAPI में एरर हैंडलिंग को लागू करते समय ध्यान रखने योग्य कुछ सर्वोत्तम प्रथाएँ यहाँ दी गई हैं:

• कस्टम एक्सेप्शन का उपयोग करें: अपने एप्लिकेशन में विशिष्ट त्रुटि स्थितियों का प्रतिनिधित्व करने के लिए कस्टम एक्सेप्शन क्लास परिभाषित करें।
• सूचनात्मक त्रुटि संदेश प्रदान करें: स्पष्ट और संक्षिप्त त्रुटि संदेश शामिल करें जो क्लाइंट को त्रुटि के कारण को समझने में मदद करते हैं।
• उपयुक्त HTTP स्टेटस कोड का उपयोग करें: HTTP स्टेटस कोड लौटाएँ जो त्रुटि की प्रकृति को सटीक रूप से दर्शाते हैं। उदाहरण के लिए, अमान्य इनपुट के लिए 400 (Bad Request), गुम संसाधनों के लिए 404 (Not Found), और अप्रत्याशित त्रुटियों के लिए 500 (Internal Server Error) का उपयोग करें।
• संवेदनशील जानकारी को उजागर करने से बचें: सावधान रहें कि त्रुटि संदेशों में संवेदनशील जानकारी जैसे डेटाबेस क्रेडेंशियल या API कुंजियों को उजागर न करें।
• त्रुटियों को लॉग करें: डिबगिंग और निगरानी उद्देश्यों के लिए विस्तृत त्रुटि जानकारी लॉग करें। पाइथन के अंतर्निहित logging मॉड्यूल जैसी लॉगिंग लाइब्रेरी का उपयोग करें।
• एरर हैंडलिंग लॉजिक को केंद्रीकृत करें: एरर हैंडलिंग लॉजिक को एक ही स्थान पर समेकित करें, जैसे कि कस्टम एक्सेप्शन हैंडलर या मिडलवेयर में।
• अपने एरर हैंडलिंग का परीक्षण करें: यह सुनिश्चित करने के लिए यूनिट टेस्ट लिखें कि आपका एरर हैंडलिंग लॉजिक सही ढंग से काम कर रहा है।
• एक समर्पित त्रुटि ट्रैकिंग सेवा का उपयोग करने पर विचार करें: उत्पादन वातावरण के लिए, त्रुटियों की निगरानी और विश्लेषण के लिए Sentry या Rollbar जैसी समर्पित त्रुटि ट्रैकिंग सेवा का उपयोग करने पर विचार करें। ये उपकरण आपके एप्लिकेशन के स्वास्थ्य के बारे में बहुमूल्य जानकारी प्रदान कर सकते हैं और आपको मुद्दों को जल्दी पहचानने और हल करने में मदद कर सकते हैं।

निष्कर्ष

कस्टम एक्सेप्शन हैंडलर FastAPI में मजबूत और उपयोगकर्ता-अनुकूल API बनाने के लिए एक शक्तिशाली उपकरण हैं। कस्टम एक्सेप्शन क्लास और हैंडलर को परिभाषित करके, आप त्रुटियों को शालीनता से प्रबंधित कर सकते हैं, ग्राहकों को सूचनात्मक प्रतिक्रियाएँ प्रदान कर सकते हैं, और अपने एप्लिकेशन की समग्र विश्वसनीयता और रखरखाव में सुधार कर सकते हैं। कस्टम एक्सेप्शन, HTTPException को मिलाकर, और जब लागू हो, i18n सिद्धांतों का लाभ उठाकर, आपकी API को वैश्विक सफलता के लिए स्थापित करता है।

अपनी एरर हैंडलिंग रणनीति को डिजाइन करते समय उपयोगकर्ता अनुभव पर विचार करना याद रखें। स्पष्ट और संक्षिप्त त्रुटि संदेश प्रदान करें जो उपयोगकर्ताओं को समस्या को समझने और इसे कैसे हल करें, में मदद करते हैं। प्रभावी एरर हैंडलिंग उच्च-गुणवत्ता वाले API बनाने का एक आधारशिला है जो एक विविध वैश्विक दर्शकों की जरूरतों को पूरा करता है।